package com.whut.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.whut.common.*;
import com.whut.entity.Courier;
import com.whut.entity.Express;
import com.whut.entity.User;
import com.whut.service.CourierService;
import com.whut.service.ExpressService;
import com.whut.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.concurrent.TimeUnit;

/**
 * 微信用户/快递员控制页面
 */
@RestController
@Slf4j
@RequestMapping("/wx")
public class WxUserController {

    @Autowired
    private UserService userService;

    @Autowired
    private CourierService courierService;

    @Autowired
    private ExpressService expressService;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 发送短信验证码
     *
     * @param request
     * @return
     */
    @GetMapping("/loginSms.do")
    public String sendSms(HttpServletRequest request, HttpSession session) {
        log.info("发送短信验证码……");
        // 获取手机号
        String phone = request.getParameter("userPhone");

        // 判断手机号是否为空
        if (StringUtils.isNotEmpty(phone)) {
            // 生成随机的四位验证码
            String code = ValidateCodeUtils.generateValidateCode(4).toString();
            log.info("code={}", code);

            // 需要将生成的验证码保存在session中
            // session.setAttribute(phone, code);

            // 将生成的验证码保存到Redis,设置过期时间
            redisTemplate.opsForValue().set(phone, code, 5, TimeUnit.MINUTES);

            return "手机验证码短信发送成功";
        }
        return "手机验证码短信发送失败";
    }

    /**
     * 移动端用户/快递员登录
     * @param request
     * @param session
     * @return
     */
    @PostMapping("/login.do")
    public Message<String> login(HttpServletRequest request, HttpSession session) {

        // 获取页面传递的手机号和验证码
        String phone = request.getParameter("userPhone");
        String code = request.getParameter("code");
        log.info("登录……电话：{}，验证码：{}",phone,code);

        // 从session中获取保存的验证码
        // final Object codeInsession = session.getAttribute(phone);

        // 从redis中获取缓存的验证码
        final Object codeInsession = redisTemplate.opsForValue().get(phone);

        // 如果验证码为空，则提示用户输入验证码
        if (code == null) {
            return Message.error("手机号未获取短信");
        }
        // 如果验证码验证通过
        if (code.equals(codeInsession)) {
            // 根据手机号分别从用户/快递员数据库中查询对应对象
            User user = userService.findByUserPhone(phone);
            Courier courier = courierService.findByPhone(phone);
            // 手机号-用户存在 登录
            if (user!=null && courier==null) {

                // 此函数将用户id保存在session中
                UserUtil.setWxUser(request.getSession(), user);
                // 登录成功后，将Redis中缓存的验证码删除
                redisTemplate.delete(phone);
                return Message.success("用户登陆成功！");

            }
            // 手机号-快递员存在 登录
            if (user==null && courier!=null) {

                UserUtil.setWxUser(request.getSession(), courier);
                // 登录成功后，将Redis中缓存的验证码删除
                redisTemplate.delete(phone);
                return Message.success("快递员登陆成功");
            }
            // 手机号-用户/快递员都存在 以快递员身份登录
            if (user!=null && courier!=null) {

                UserUtil.setWxUser(request.getSession(), courier);
                // 登录成功后，将Redis中缓存的验证码删除
                redisTemplate.delete(phone);
                return Message.success("快递员登陆成功");
            }
            // 手机号-用户/快递员均不存在 注册
            if (user==null && courier==null) {
                return Message.error("用户不存在");
            }
        }
        return Message.error("验证码错误！");
    }

    /**
     * 退出登录
     *
     * @param request
     * @return
     */
    @GetMapping("/logout.do")
    public Message<String> logout(HttpServletRequest request) {
        // 退出登录 将session设置为失效
        request.getSession().removeAttribute("wxUser");
        request.getSession().removeAttribute("user");
        request.getSession().removeAttribute("courier");
        return Message.success("退出登录成功！");
    }

    /**
     * 修改用户信息 发送验证码
     * @param request
     * @param session
     * @return
     */
    @GetMapping("/updateSms.do")
    public String updateSms(HttpServletRequest request, HttpSession session) {
        log.info("修改短信验证码……");
        // 获取手机号
        String phone = request.getParameter("userPhone");

        // 判断手机号是否为空
        if (StringUtils.isNotEmpty(phone)) {
            // 生成随机的四位验证码
            String code = ValidateCodeUtils.generateValidateCode(4).toString();
            log.info("code={}", code);

            // 需要将生成的验证码保存在session中
            session.setAttribute(phone, code);

            return "手机验证码短信发送成功";
        }
        return "手机验证码短信发送失败";
    }

    /**
     * 用户/快递员
     * @param request
     * @param response
     * @return
     */
    @GetMapping("/userInfo.do")
    public Message<String> userInfo(HttpServletRequest request, HttpServletResponse response){
        // 获取session中的手机号码
        String phone = (String) request.getSession().getAttribute("phone");
        LambdaQueryWrapper<Courier> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Courier::getSysPhone, phone);
        Courier courier = courierService.getOne(queryWrapper);
        boolean isUser = false;
        // 因为已经登陆 所以只能是用户 或 快递员 而电话号码相同时 以快递员身份登录 所以分为 不是快递员 和 是快递员两种
        // 只有在不可能是快递员时才是用户
        if (courier == null) {
            isUser = true;
        }

        // 判断是用户还是快递员
        Message<String> msg = new Message();
        // 用户
        if(isUser)
            return Message.success("用户登录");
        // 快递员
        else
            return Message.error("快递员登录");
    }

    /**
     * 根据快递单号查找快递
     * @param request
     * @param response
     * @return
     */
    @PostMapping("/searchExpress.do")
    public Message<String> searchExpress(HttpServletRequest request, HttpServletResponse response){
        // 快递单号
        String expressNum = request.getParameter("expressNum");
        // 用户 / 快递员
        Object wxUser = UserUtil.getWxUser(request.getSession());
        // 手机号码
        String userPhone = "";
        // 如果是用户
        if (wxUser instanceof User){
            userPhone = ((User) wxUser).getUserPhone();
        }
        // 如果是快递员
        else if (wxUser instanceof Courier){
            userPhone = ((Courier) wxUser).getSysPhone();
        }

        // 根据快递单号获取快递
        LambdaQueryWrapper<Express> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Express::getNumber, expressNum);
        Express express = expressService.getOne(queryWrapper);

        System.out.println(express);

        // 根据快递单号查找到快递 并且 用户号码正确
        if (express != null && express.getPhone().equals(userPhone)){
            HttpSession session = request.getSession();
            session.setAttribute("searchExpress",express);
        }
        return Message.success("查询成功");
    }


    /**
     * 修改用户 or 快递员信息
     * @param request
     * @param session
     * @return
     */
    @PostMapping("/update.do")
    public Message<String> update(HttpServletRequest request, HttpSession session) {
        // 前端传来的内容
        String name = request.getParameter("newName");
        String phone = request.getParameter("newPhone");
        String verify = request.getParameter("verify");

        // 如果验证码为空
        if (verify == null) {
            return Message.error("请输入验证码");
        }
        // 从session中获取的验证码
        // final Object code = session.getAttribute(phone);

        // 从redis中获取缓存的验证码
        final Object code = redisTemplate.opsForValue().get(phone);

        // 验证通过 需要根据 用户 or 快递员 处理不同的表数据
        if (verify.equals(code)) {
            // 获取登录时保存的对象
            Object wxUser = UserUtil.getWxUser(request.getSession());
            // 判断是用户 还是 快递员
            if (wxUser instanceof User){
                LambdaQueryWrapper<User> queryWrapper1 = new LambdaQueryWrapper<>();
                queryWrapper1.eq(User::getId, BaseContext.getCurrentId());
                User user = userService.getOne(queryWrapper1);
                user.setUsername(name);
                user.setUserPhone(phone);
                boolean update = userService.updateById(user);
            }
            else if (wxUser instanceof Courier) {
                LambdaQueryWrapper<Courier> queryWrapper2 = new LambdaQueryWrapper<>();
                queryWrapper2.eq(Courier::getId, BaseContext.getCurrentId());
                Courier courier = courierService.getOne(queryWrapper2);
                courier.setName(name);
                courier.setSysPhone(phone);
                boolean update = courierService.updateById(courier);
            }
        }
        else {
            return Message.error("验证码不一致，请重新发送！");
        }
        redisTemplate.delete(phone);
        return Message.success("success");
    }

    /**
     * 个人中心信息显示
     * @param request
     * @param response
     * @return
     */
    @ResponseBody
    @GetMapping("/userName.do")
    public String userName(HttpServletRequest request, HttpServletResponse response){
        Object loginUser = UserUtil.getWxUser(request.getSession());
        boolean isUser = loginUser instanceof User;
        String name;
        if (isUser){
            name = ((User) loginUser).getUsername();
        }
        else {
            name = ((Courier) loginUser).getName();
        }
        return name;
    }

    /**
     * 用户认证
     * @param request
     * @param session
     * @return
     */
    @PostMapping("/eck.do")
    public Message<String> check(HttpServletRequest request, HttpSession session) {
        // 前端传来的内容
        String name = request.getParameter("name");
        String phone = request.getParameter("phone");
        String password = request.getParameter("password");
        String code = request.getParameter("code");

        // 如果验证码为空
        if (code == null) {
            return Message.error("请输入验证码");
        }
        // 从session中获取验证码
        // final Object codeInsession = session.getAttribute(phone);
        // 从redis中获取缓存的验证码
        final Object codeInsession = redisTemplate.opsForValue().get(phone);

        // 验证通过 需要根据 用户 or 快递员 处理不同的表数据
        if (code.equals(codeInsession)) {
            // 获取登录时保存的对象
            Object wxUser = UserUtil.getWxUser(request.getSession());
            // 判断是用户 还是 快递员
            if (wxUser instanceof User){
                LambdaQueryWrapper<User> queryWrapper1 = new LambdaQueryWrapper<>();
                queryWrapper1.eq(User::getId, BaseContext.getCurrentId());
                queryWrapper1.eq(User::getUserPhone, phone);
                queryWrapper1.eq(User::getPassword, password);
                User user = userService.getOne(queryWrapper1);
                if (user != null) {
                    user.setUsername(name);
                    userService.updateById(user);
                }
                else {
                    return Message.error("请输入正确信息");
                }
            }
            else if (wxUser instanceof Courier) {
                LambdaQueryWrapper<Courier> queryWrapper2 = new LambdaQueryWrapper<>();
                queryWrapper2.eq(Courier::getId, BaseContext.getCurrentId());
                queryWrapper2.eq(Courier::getSysPhone, phone);
                queryWrapper2.eq(Courier::getPassword, phone);
                Courier courier = courierService.getOne(queryWrapper2);
                if (courier != null) {
                    courier.setName(name);
                    courierService.updateById(courier);
                }
                else {
                    return Message.error("请输入正确信息");
                }
            }
        }
        else {
            return Message.error("验证码不一致，请重新发送！");
        }
        redisTemplate.delete(phone);
        return Message.success("success");

    }
}

